home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Environments / SmallEiffel 0.3.3 / SmallEiffel PPC / diff / lib_std.old < prev    next >
Encoding:
Text File  |  1996-06-13  |  27.1 KB  |  1,112 lines  |  [TEXT/EDIT]
  1. Only in /users/prof/colnet/SmallEiffel/lib_std: arguments.e
  2. diff -r lib_std/array.e /users/prof/colnet/SmallEiffel/lib_std/array.e
  3. 37,38c37,38
  4. <      if storage /= Void then
  5. <         c_inline_c("free(C->_storage);");
  6. ---
  7. >      if storage.is_not_void then
  8. >         free_pointer(storage);
  9. 43d42
  10. <      storage := Void;
  11. 46,47c45
  12. <         c_inline_c("C->_storage=malloc%
  13. <                %((size_t)((C->_capacity)*sizeof(*(C->_storage))));");
  14. ---
  15. >         storage := malloc(capacity);
  16. 80,81c78,79
  17. <      if storage /= Void then
  18. <         c_inline_c("free(C->_storage);");
  19. ---
  20. >      if storage.is_not_void then
  21. >         free_pointer(storage);
  22. 83c81,82
  23. <      c_inline_c("memcpy(C,_other,sizeof(*C));free(_other);");
  24. ---
  25. >      standard_copy(other);
  26. >      other.free_array;
  27. 88c87
  28. <    infix "@", item (index: INTEGER): E is
  29. ---
  30. >    item, infix "@" (index: INTEGER): E is
  31. 90,94c89,91
  32. <      check
  33. <         storage /= Void;
  34. <         capacity >= (upper - lower + 1);
  35. <      end;
  36. <      c_inline_c("R=(C->_storage)[a1-(C->_lower)];")
  37. ---
  38. >      if storage = Void then end;
  39. >      if lower = Void then end;
  40. >      c_inline_c("R=(((C->_storage))[a1-(C->_lower)]);")
  41. 102c99,101
  42. <      c_inline_c("(C->_storage)[a2-(C->_lower)]=a1;");
  43. ---
  44. >      if storage = Void then end;
  45. >      if lower = Void then end;
  46. >      c_inline_c("((C->_storage)[a2-(C->_lower)])=a1;");
  47. 205a205
  48. >      if storage = Void then end;
  49. 207,209c207,209
  50. <         capacity := capacity + 16;
  51. <         if capacity = 16 then
  52. <            c_inline_c("C->_storage=malloc(16*sizeof(*(C->_storage)));");
  53. ---
  54. >         if capacity = 0 then
  55. >            capacity := 16;
  56. >            storage := malloc(capacity);
  57. 211,212c211,212
  58. <            c_inline_c("C->_storage=realloc(C->_storage,%
  59. <               %((C->_capacity)*sizeof(*(C->_storage))));");
  60. ---
  61. >            capacity := capacity + 16;
  62. >            storage := realloc(storage,capacity);
  63. 322c322,353
  64. <       
  65. ---
  66. > 
  67. > feature {NONE}
  68. > 
  69. >    malloc(size: INTEGER): POINTER is
  70. >       require
  71. >      size > 0
  72. >       do
  73. >      c_inline_c("R=malloc((size_t)(a1*sizeof(*(C->_storage))));");
  74. >       end;
  75. > 
  76. >    realloc(pointer: POINTER; size: INTEGER): POINTER is
  77. >       require
  78. >      size > 0
  79. >       do           
  80. >      c_inline_c("R=realloc(a1,%
  81. >              %((size_t)(a2*sizeof(*(C->_storage)))));");
  82. >       end;
  83. > 
  84. >    free_pointer(p: POINTER) is
  85. >       require
  86. >      p.is_not_void
  87. >       external "C"
  88. >       alias "free"
  89. >       end;
  90. > 
  91. > feature {ARRAY}
  92. > 
  93. >    free_array is
  94. >       external "CWC"
  95. >       alias "free"
  96. >       end;
  97. > 
  98. 326c357,359
  99. <       
  100. ---
  101. > 
  102. >    capacity > 0 implies storage.is_not_void;
  103. > 
  104. diff -r lib_std/array.e /users/prof/colnet/SmallEiffel/lib_std/array.elib_std/boolean.e /users/prof/colnet/SmallEiffel/lib_std/boolean.e
  105. 20c20,21
  106. <       external "CSE"
  107. ---
  108. >       do
  109. >      Result := Current and then other;
  110. 35c36,37
  111. <       external "CSE"
  112. ---
  113. >       do
  114. >      Result := Current or else other;
  115. 55c57,61
  116. <       external "CSE"
  117. ---
  118. >       do
  119. >      if Current then
  120. >      else
  121. >         Result := true;
  122. >      end;
  123. diff -r lib_std/boolean.e /users/prof/colnet/SmallEiffel/lib_std/boolean.elib_std/boolean_ref.e /users/prof/colnet/SmallEiffel/lib_std/boolean_ref.e
  124. 11,12c11
  125. < creation {ANY}
  126. <     make
  127. ---
  128. > creation make
  129. 14c13
  130. < feature {ANY}
  131. ---
  132. > feature 
  133. 22a22,28
  134. >       end;
  135. > 
  136. > feature
  137. >    
  138. >    set_item(value: like item) is
  139. >       do
  140. >      item := value;
  141. diff -r lib_std/boolean_ref.e /users/prof/colnet/SmallEiffel/lib_std/boolean_ref.elib_std/character.e /users/prof/colnet/SmallEiffel/lib_std/character.e
  142. 22c22
  143. <    infix "<"(other: CHARACTER): BOOLEAN is
  144. ---
  145. >    infix "<" (other: CHARACTER): BOOLEAN is
  146. 24c24,25
  147. <       external "CSE"
  148. ---
  149. >       do
  150. >      Result := code < other.code;
  151. 29c30,31
  152. <       external "CSE"
  153. ---
  154. >       do
  155. >      Result := code <= other.code;
  156. 34c36,37
  157. <       external "CSE"
  158. ---
  159. >       do
  160. >      Result := code > other.code;
  161. 39c42,43
  162. <       external "CSE"
  163. ---
  164. >       do
  165. >      Result := code >= other.code;
  166. 62c66
  167. <    same_as(other : CHARACTER): BOOLEAN is
  168. ---
  169. >    same_as(other: CHARACTER): BOOLEAN is
  170. 65c69,80
  171. <      Result := to_lower = other.to_lower;
  172. ---
  173. >      if Current = other then
  174. >         Result := true;
  175. >      else
  176. >         inspect
  177. >            code
  178. >         when 65 .. 90 then
  179. >            Result := Current = other.to_upper;
  180. >         when 97 .. 122 then
  181. >            Result := Current = other.to_lower;
  182. >         else
  183. >         end;
  184. >      end;
  185. diff -r lib_std/character.e /users/prof/colnet/SmallEiffel/lib_std/character.elib_std/character_ref.e /users/prof/colnet/SmallEiffel/lib_std/character_ref.e
  186. 8,9c8
  187. < creation {ANY}
  188. <    make
  189. ---
  190. > creation make
  191. 11c10
  192. < feature {ANY}
  193. ---
  194. > feature 
  195. 19a19,25
  196. > feature
  197. >    
  198. >    set_item(value: like item) is
  199. >       do
  200. >      item := value;
  201. >       end;
  202. > 
  203. diff -r lib_std/character_ref.e /users/prof/colnet/SmallEiffel/lib_std/character_ref.elib_std/double_ref.e /users/prof/colnet/SmallEiffel/lib_std/double_ref.e
  204. 17,18c17
  205. < creation {ANY}
  206. <    make
  207. ---
  208. > creation make
  209. 20c19
  210. < feature {ANY}
  211. ---
  212. > feature 
  213. 28a28,34
  214. > feature
  215. >    
  216. >    set_item(value: like item) is
  217. >       do
  218. >      item := value;
  219. >       end;
  220. > 
  221. diff -r lib_std/double_ref.e /users/prof/colnet/SmallEiffel/lib_std/double_ref.elib_std/fixed_array.e /users/prof/colnet/SmallEiffel/lib_std/fixed_array.e
  222. 20c20
  223. <    make, resize
  224. ---
  225. >    make, resize, from_collection
  226. 41a42,43
  227. >       local
  228. >      model: like item;
  229. 43,44c45,48
  230. <      if storage /= Void then
  231. <         c_inline_c("free(C->_storage);");
  232. ---
  233. >      if storage.is_not_void then
  234. >         storage := realloc(storage,size,model);
  235. >      else
  236. >         storage := malloc(size,model);
  237. 46,47d49
  238. <      c_inline_c("C->_storage=malloc(((size_t)%
  239. <             %sizeof(*(C->_storage))*a1));");
  240. 53a56,74
  241. > 
  242. >    from_collection(cltn: COLLECTION[E]) is
  243. >       local
  244. >      fa_index, cltn_index: INTEGER;
  245. >       do
  246. >      from
  247. >         make(cltn.count);
  248. >         fa_index := upper;
  249. >         cltn_index := cltn.upper;
  250. >      until
  251. >         fa_index < 0
  252. >      loop
  253. >         put(cltn.item(cltn_index),fa_index);
  254. >         cltn_index := cltn_index - 1;
  255. >         fa_index := fa_index - 1;
  256. >      end;
  257. >       ensure
  258. >      count = cltn.count
  259. >       end;
  260. 59c80,81
  261. <      c_inline_c("R=(C->_storage)[a1];")
  262. ---
  263. >      if storage = Void then end;
  264. >      c_inline_c("R=((C->_storage)[a1]);")
  265. 66c88
  266. <      c_inline_c("(C->_storage)[a2]=a1;");
  267. ---
  268. >      c_inline_c("((C->_storage)[a2])=a1;");
  269. 73,76d94
  270. <      if storage /= Void then
  271. <         c_inline_c("free(C->_storage);");
  272. <         storage := Void;
  273. <      end;
  274. 157c175,191
  275. <       
  276. ---
  277. > 
  278. > feature {NONE}
  279. > 
  280. >    malloc(size: INTEGER; model: like item): POINTER is
  281. >       require
  282. >      size > 0
  283. >       do
  284. >      c_inline_c("R=malloc((size_t)(a1*sizeof(a2)));");
  285. >       end;
  286. > 
  287. >    realloc(pointer: POINTER; size: INTEGER; model: like item): POINTER is
  288. >       require
  289. >      size > 0
  290. >       do
  291. >      c_inline_c("R=realloc(a1,(size_t)(a2*sizeof(a3)));");
  292. >       end;
  293. > 
  294. diff -r lib_std/fixed_array.e /users/prof/colnet/SmallEiffel/lib_std/fixed_array.elib_std/general.e /users/prof/colnet/SmallEiffel/lib_std/general.e
  295. 123c123
  296. < -- ELKS problem for expanded target.
  297. ---
  298. > -- ELKS95 bug for expanded target.
  299. 158c158,159
  300. <      same_type: Result implies same_type(other);
  301. ---
  302. > -- ***     same_type: Result implies same_type(other);
  303. > -- ELKS95 bug for expanded target.
  304. 165,166c166,167
  305. <      -- Void if `other' is Void; otherwise new object 
  306. <      -- equal to `other'. 
  307. ---
  308. >      -- When argument `other' is Void, call `twin' otherwise 
  309. >      -- return Void. 
  310. 169c170,190
  311. <         c_inline_c("R=(T0 *)se_new(a1->id);");
  312. ---
  313. >         Result := other.twin;
  314. >      end;
  315. >       ensure
  316. >      equal: equal(Result,other);
  317. >       end;
  318. > 
  319. >    frozen twin: like Current is
  320. >      -- Return an initialized new object using target as model.
  321. >      -- Result as the same `generating_type' as the target of the 
  322. >      -- call. Before to be returned, the corresponding `copy' feature
  323. >      -- is called.
  324. >       do
  325. >      if is_expanded_type then
  326. >         if is_basic_expanded_type then
  327. >            Result := Current;
  328. >         else
  329. >            Result := Current;
  330. >            Result.copy(Current);
  331. >         end;
  332. >      else
  333. >         c_inline_c("R=(T0 *)se_new(C->id);");
  334. 171c192
  335. <         Result.copy(other);
  336. ---
  337. >         Result.copy(Current);
  338. 175c196
  339. <      equal: equal(Result,other);
  340. ---
  341. >      equal: Result.is_equal(Current);
  342. 345c366
  343. <       external "CSE"
  344. ---
  345. >       do
  346. 352a374,375
  347. >       local
  348. >      p: POINTER;
  349. 354c377
  350. <      path.extend('%U');
  351. ---
  352. >      p := path.to_external;
  353. 356c379
  354. <          "{FILE *f=fopen(((T7 *)a1)->_storage,%"r%");%N%
  355. ---
  356. >          "{FILE *f=fopen(((char*)_p),%"r%");%N%
  357. 359d381
  358. <      path.remove_last(1);
  359. 364a387,388
  360. >       local
  361. >      p: POINTER;
  362. 366,368c390,391
  363. <      path.extend('%U');
  364. <      c_inline_c("remove(((T7 *)a1)->_storage);");
  365. <      path.remove_last(1);
  366. ---
  367. >      p := path.to_external;
  368. >      c_inline_c("remove(((char*)_p));");
  369. 374a398,399
  370. >       local
  371. >      op, np: POINTER;
  372. 376,380c401,403
  373. <      old_path.extend('%U');
  374. <      new_path.extend('%U');
  375. <      c_inline_c("rename(((T7 *)a1)->_storage,((T7 *)a2)->_storage);");
  376. <      old_path.remove_last(1);
  377. <      new_path.remove_last(1);
  378. ---
  379. >      op := old_path.to_external;
  380. >      np := new_path.to_external;
  381. >      c_inline_c("rename(((char*)_op),((char*)_np));");
  382. 388c411,412
  383. <       external "CSE"
  384. ---
  385. >       do
  386. >      Result := command_arguments.upper;
  387. 399c423,424
  388. <       external "CSE"
  389. ---
  390. >       do
  391. >      Result := command_arguments.item(i);
  392. 402a428,450
  393. > 
  394. >    frozen command_arguments: ARRAY[STRING] is
  395. >      --                  ***** FIXED_ARRAY[STRING]
  396. >      -- Give an acces to arguments command line including the
  397. >      -- command name at index 0.
  398. >       local
  399. >      i: INTEGER;
  400. >      arg: STRING;
  401. >       once
  402. >      from
  403. >         c_inline_c("_i=se_argc-1;");
  404. >         !!Result.make(0,i);
  405. >      until
  406. >         i < 0
  407. >      loop
  408. >         c_inline_c("_arg=((T0*)e2s(se_argv[_i]));");
  409. >         Result.put(arg,i);
  410. >         i := i - 1;
  411. >      end;
  412. >       ensure
  413. >      Result.lower = 0; -- *****  FIXED_ARRAY 
  414. >      not Result.empty
  415. >       end;
  416. 409a458,459
  417. >       local
  418. >      p: POINTER;
  419. 411,414c461,465
  420. <      name.extend('%U');
  421. <      c_inline_c("R=((T0 *)getenv(((T7 *)a1)->_storage));%N%
  422. <             %if (R) R=((T0 *)e2s((char *)R));")
  423. <      name.remove_last(1);
  424. ---
  425. >      p := name.to_external;
  426. >      c_inline_c("_p=((void*)getenv((char*)_p));");
  427. >      if p.is_not_void then
  428. >         c_inline_c("R=(T0*)e2s((char*)_p);");
  429. >      end;
  430. 423a475,476
  431. >       local
  432. >      p: POINTER;
  433. 425,427c478,479
  434. <      cmd.extend('%U');
  435. <      c_inline_c("system(((T7 *)a1)->_storage);");
  436. <      cmd.remove_last(1);
  437. ---
  438. >      p := cmd.to_external;
  439. >      c_inline_c("system(((char*)_p));");
  440. 519c571
  441. <      -- Statically computed by SmallEiffel.
  442. ---
  443. >      -- Target is not evaluated (Statically computed).
  444. 521d572
  445. <      -- Target is not evaluated.
  446. 525a577,586
  447. >    frozen is_basic_expanded_type: BOOLEAN is
  448. >      -- Target is not evaluated (Statically computed).
  449. >      -- Result is true if target static type is one of the 
  450. >      -- following types : BOOLEAN, CHARACTER, INTEGER, REAL,
  451. >      -- DOUBLE or POINTER.
  452. >       external "CSE"
  453. >       ensure
  454. >      Result implies is_expanded_type
  455. >       end;
  456. >    
  457. 529,530c590
  458. <      -- The result is the C sizeof of the corresponding
  459. <      -- struct or basic object.
  460. ---
  461. >      -- The result is given in number of CHARACTER.
  462. 552a613,625
  463. >       end;
  464. > 
  465. > feature -- WARNING: For SmallEiffel Gurus's only. 
  466. >    -- Internal implementation of the SmallEiffel 
  467. >    -- debugger/interpretor (command `eval').
  468. > 
  469. >    eval_read_attribute(name: STRING; dest: POINTER) is do end;
  470. > 
  471. >    eval_write_attribute(name: STRING; source: POINTER) is do end;
  472. > 
  473. >    frozen eval_virtual_machine: EVAL_VIRTUAL_MACHINE is
  474. >       once
  475. >      !!Result.make;
  476. diff -r lib_std/general.e /users/prof/colnet/SmallEiffel/lib_std/general.elib_std/integer.e /users/prof/colnet/SmallEiffel/lib_std/integer.e
  477. 11,13c11,14
  478. <      infix "+", infix "-", infix "*", infix "/", infix "\\", infix "//", 
  479. <      infix "^", infix "<", infix "<=", infix ">", infix ">=", compare, 
  480. <      prefix "-", prefix "+", hash_code, one, zero, print_on
  481. ---
  482. >      infix "+", infix "-", infix "*", infix "/", infix "\\", 
  483. >      infix "//", infix "^", infix "<", infix "<=", infix ">",
  484. >      infix ">=", compare, prefix "-", prefix "+", hash_code, 
  485. >      one, zero, print_on
  486. 74c75
  487. <      -- Is Current smaller than `other'?
  488. ---
  489. >      -- Is 'Current' strictly less than 'other'?
  490. 79c80
  491. <      -- Is Current smaller or equal to `other'?
  492. ---
  493. >      -- Is 'Current' less or equal 'other'?
  494. 84c85
  495. <      -- Is Current greater than `other'?
  496. ---
  497. >      -- Is 'Current' strictly greater than 'other'?
  498. 89c90
  499. <      -- Is Current greater or equal to `other'?
  500. ---
  501. >      -- Is 'Current' greater or equal than 'other'?
  502. 134c135
  503. <      Result := to_real.sqrt;
  504. ---
  505. >      Result := to_double.sqrt;
  506. 176a178,184
  507. >    to_boolean: BOOLEAN is
  508. >       do
  509. >      if Current /= 0 then
  510. >         Result := true;
  511. >      end;
  512. >       end;
  513. > 
  514. 295c303,306
  515. <    tmp_string: STRING is "0000000000000000000";
  516. ---
  517. >    tmp_string: STRING is 
  518. >       once
  519. >      !!Result.make(128);
  520. >       end;
  521. diff -r lib_std/integer.e /users/prof/colnet/SmallEiffel/lib_std/integer.elib_std/integer_ref.e /users/prof/colnet/SmallEiffel/lib_std/integer_ref.e
  522. 17,18c17
  523. < creation {ANY}
  524. <    make
  525. ---
  526. > creation make
  527. 20c19
  528. < feature {ANY}
  529. ---
  530. > feature 
  531. 28a28,34
  532. > feature
  533. >    
  534. >    set_item(value: like item) is
  535. >       do
  536. >      item := value;
  537. >       end;
  538. > 
  539. diff -r lib_std/integer_ref.e /users/prof/colnet/SmallEiffel/lib_std/integer_ref.elib_std/platform.e /users/prof/colnet/SmallEiffel/lib_std/platform.e
  540. 8,9c8
  541. <    
  542. < feature {ANY}
  543. ---
  544. > feature -- Maximum :
  545. 11c10,16
  546. <     Maximum_character_code : INTEGER is 255
  547. ---
  548. >     Maximum_character_code : INTEGER is
  549. >      -- Largest supported code for CHARACTER values.
  550. >       once
  551. >      c_inline_c("R=CHAR_MAX;");
  552. >       ensure
  553. >      meaningful: Result >= 127
  554. >       end;
  555. 13c18,24
  556. < end -- class PLATFORM
  557. ---
  558. >     Maximum_integer: INTEGER is
  559. >       -- Largest supported value of type INTEGER.
  560. >       once
  561. >      c_inline_c("R=INT_MAX;");
  562. >       ensure
  563. >      meaningful: Result >= 0
  564. >       end;
  565. 14a26,127
  566. >     Maximum_real: REAL is
  567. >       -- Largest supported value of type REAL.
  568. >       once
  569. >      c_inline_c("R=FLT_MAX;");
  570. >       ensure
  571. >      meaningful: Result >= 0.0
  572. >       end;
  573. > 
  574. >     Maximum_double: DOUBLE is
  575. >       -- Largest supported value of type DOUBLE.
  576. >       once
  577. >      c_inline_c("R=DBL_MAX;");
  578. >       ensure
  579. >      meaningful: Result >= 0.0
  580. >       end;
  581. > 
  582. > feature -- Minimum :
  583. > 
  584. >    Minimum_character_code: INTEGER is
  585. >       -- Smallest supported code for CHARACTER values.
  586. >       once
  587. >      c_inline_c("R=CHAR_MIN;");
  588. >       ensure
  589. >      meaningful: Result <= 0
  590. >       end;
  591. > 
  592. >    Minimum_integer: INTEGER is
  593. >       -- Smallest supported value of type INTEGER.
  594. >       once
  595. >      c_inline_c("R=INT_MIN;");
  596. >       ensure
  597. >      meaningful: Result <= 0
  598. >       end;
  599. > 
  600. >    Minimum_double: DOUBLE is
  601. >       -- Smallest supported value of type DOUBLE.
  602. >       once
  603. >      Result := - Maximum_double;
  604. >       ensure
  605. >      meaningful: Result <= 0
  606. >       end;
  607. > 
  608. >    Minimum_real: REAL is
  609. >       -- Smallest supported value of type REAL.
  610. >       once
  611. >      Result := - Maximum_real;
  612. >       ensure
  613. >      meaningful: Result <= 0
  614. >       end;
  615. > 
  616. > feature -- Bits :
  617. > 
  618. >    Boolean_bits: INTEGER is
  619. >       -- Number of bits in a value of type BOOLEAN.
  620. >       once
  621. >      c_inline_c("R=(CHAR_BIT*sizeof(int));");
  622. >       ensure
  623. >      meaningful: Result >= 1
  624. >       end;
  625. > 
  626. >    Character_bits: INTEGER is
  627. >       -- Number of bits in a value of type CHARACTER.
  628. >       once
  629. >      c_inline_c("R=CHAR_BIT;");
  630. >       ensure
  631. >      meaningful: Result >= 1;
  632. >      large_enough: (2^Result) >= Maximum_character_code;
  633. >       end;
  634. > 
  635. >    Integer_bits: INTEGER is
  636. >      -- Number of bits in a value of type INTEGER.
  637. >       once
  638. >      c_inline_c("R=(CHAR_BIT*sizeof(int));");
  639. >       ensure
  640. >      meaningful: Result >= 1;
  641. >       end;
  642. > 
  643. >    Real_bits: INTEGER is
  644. >      -- Number of bits in a value of type DOUBLE.
  645. >       once
  646. >      c_inline_c("R=(CHAR_BIT*sizeof(float));");
  647. >       ensure
  648. >      meaningful: Result >= 1;
  649. >      meaningful: Result >= Real_bits;
  650. >       end;
  651. > 
  652. >    Double_bits: INTEGER is
  653. >      -- Number of bits in a value of type DOUBLE.
  654. >       once
  655. >      c_inline_c("R=(CHAR_BIT*sizeof(double));");
  656. >       ensure
  657. >      meaningful: Result >= 1;
  658. >      meaningful: Result >= Real_bits;
  659. >       end;
  660. > 
  661. >    Pointer_bits: INTEGER is
  662. >      -- Number of bits in a value of type REAL.
  663. >       once
  664. >      c_inline_c("R=(CHAR_BIT*sizeof(char *));");
  665. >       end;
  666. > 
  667. > end -- PLATFORM
  668. diff -r lib_std/platform.e /users/prof/colnet/SmallEiffel/lib_std/platform.elib_std/pointer.e /users/prof/colnet/SmallEiffel/lib_std/pointer.e
  669. 9,12c9,18
  670. < -- Note : corresponding C type is usually "void *".
  671. < --    In type STRING, POINTER is mapped "char *".
  672. < --    In type ARRAY and FIXED_ARRAY, POINTER is mapped as the 
  673. < --    C type of the generic actual argument.
  674. ---
  675. > -- Note : corresponding C type is mapped as "void *" except for
  676. > --        source files "string.e", "array.e" and "fixed_array.e".
  677. > --        In file "string.e", type POINTER is simply mapped as
  678. > --        the usual C type "char*".
  679. > --        In files "array.e" and "fixed_array.e", the mapping depends
  680. > --        on the actual generic type. When the actual generic type
  681. > --        is a reference type, POINTER is mapped as C type "T0 **".
  682. > --        When the actual type is an expanded type, POINTER is mapped 
  683. > --        as "<Ti>*" where <Ti> is the corresponding type of expanded
  684. > --        actual generic argument.
  685. 13a20
  686. > 
  687. 19a27,40
  688. > 
  689. >    is_not_void: BOOLEAN is
  690. >      -- Is the external POINTER a non Void pointer ?
  691. >      --  
  692. >      -- NOTE: as POINTER is an expanded class, the Eiffel
  693. >      --       test  Current /= Void is always true.
  694. >      --
  695. >       external "CSE"
  696. >       end;
  697. > 
  698. >    is_void: BOOLEAN is
  699. >       do
  700. >      Result := not is_not_void;
  701. >       end;
  702. diff -r lib_std/pointer.e /users/prof/colnet/SmallEiffel/lib_std/pointer.elib_std/pointer_ref.e /users/prof/colnet/SmallEiffel/lib_std/pointer_ref.e
  703. 10c10,15
  704. < end -- class INTEGER_REF
  705. ---
  706. >    set_item(value: like item) is
  707. >       do
  708. >      item := value;
  709. >       end;
  710. > 
  711. > end -- POINTER_REF
  712. diff -r lib_std/pointer_ref.e /users/prof/colnet/SmallEiffel/lib_std/pointer_ref.elib_std/real_ref.e /users/prof/colnet/SmallEiffel/lib_std/real_ref.e
  713. 17,18c17
  714. < creation {ANY}
  715. <    make
  716. ---
  717. > creation make
  718. 20c19
  719. < feature {ANY}
  720. ---
  721. > feature 
  722. 28a28,34
  723. > feature
  724. >    
  725. >    set_item(value: like item) is
  726. >       do
  727. >      item := value;
  728. >       end;
  729. > 
  730. diff -r lib_std/real_ref.e /users/prof/colnet/SmallEiffel/lib_std/real_ref.elib_std/std_error.e /users/prof/colnet/SmallEiffel/lib_std/std_error.e
  731. 39c39
  732. < feature {NONE}   
  733. ---
  734. > feature {RUN_FEATURE}   
  735. diff -r lib_std/std_error.e /users/prof/colnet/SmallEiffel/lib_std/std_error.elib_std/std_file.e /users/prof/colnet/SmallEiffel/lib_std/std_file.e
  736. 49,50c49
  737. <    -- NOTE: use only a few basic ANSI C functions.
  738. <    -- Try to use a as less as possible external C calls.
  739. ---
  740. >    -- NOTE: use only a few basic external C calls.
  741. 58a58,59
  742. >       local
  743. >      pf, pm: POINTER;
  744. 60,65c61,63
  745. <      f.extend('%U');
  746. <      m.extend('%U');
  747. <      c_inline_c("R=(T0 *)fopen(((Tstring *)a1)->_storage,%
  748. <              %((Tstring *)a2)->_storage);");
  749. <      f.remove_last(1);
  750. <      m.remove_last(1);
  751. ---
  752. >      pf := f.to_external;
  753. >      pm := m.to_external;
  754. >      c_inline_c("R=(void*)fopen(((char*)_pf),((char*)_pm));");
  755. 70d67
  756. <       alias "fclose"
  757. 71a69,72
  758. > 
  759. >    fputc(c: CHARACTER; stream_pointer: POINTER): CHARACTER is
  760. >       external "C"
  761. >       end;
  762. 72a74,83
  763. >    fgetc(stream_pointer : POINTER): CHARACTER is
  764. >      -- Result is of type CHARACTER because a int is a char !
  765. >       external "C"
  766. >       end;
  767. > 
  768. >    feof(stream_ptr: POINTER): BOOLEAN is
  769. >       do
  770. >      c_inline_c("R=feof((FILE*)C->_input_stream);");
  771. >       end;
  772. > 
  773. diff -r lib_std/std_file.e /users/prof/colnet/SmallEiffel/lib_std/std_file.elib_std/std_file_read.e /users/prof/colnet/SmallEiffel/lib_std/std_file_read.e
  774. 313,323d312
  775. <    
  776. <    fgetc(stream_pointer : POINTER): CHARACTER is
  777. <      -- Result is of type CHARACTER because a int is a char !
  778. <       external "CSE"
  779. <       alias "fgetc"
  780. <       end;
  781. < 
  782. <    
  783. <    feof(stream_ptr: POINTER): BOOLEAN is
  784. <       external "CSE"
  785. <       end;
  786. diff -r lib_std/std_file_read.e /users/prof/colnet/SmallEiffel/lib_std/std_file_read.elib_std/std_file_write.e /users/prof/colnet/SmallEiffel/lib_std/std_file_write.e
  787. 16,17c16
  788. < creation {ANY}
  789. <    connect_to
  790. ---
  791. > creation connect_to
  792. 19c18
  793. < feature {ANY}
  794. ---
  795. > feature 
  796. 38c37
  797. < feature {ANY}   
  798. ---
  799. > feature    
  800. 63c62
  801. <         put_character(s @ i);
  802. ---
  803. >         put_character(s.item(i));
  804. 192,193c191,193
  805. <    fputc(c: CHARACTER; stream_pointer: POINTER): CHARACTER is
  806. <       external "CSE"
  807. ---
  808. >    tmp_string: STRING is
  809. >       once
  810. >      !!Result.make(512);
  811. 195,196d194
  812. <    
  813. <    tmp_string: STRING is "0123456789001234567890";   
  814. diff -r lib_std/std_file_write.e /users/prof/colnet/SmallEiffel/lib_std/std_file_write.elib_std/std_input.e /users/prof/colnet/SmallEiffel/lib_std/std_input.e
  815. 40c40
  816. < feature {NONE} 
  817. ---
  818. > feature {RUN_FEATURE} 
  819. diff -r lib_std/std_input.e /users/prof/colnet/SmallEiffel/lib_std/std_input.elib_std/std_output.e /users/prof/colnet/SmallEiffel/lib_std/std_output.e
  820. 39c39
  821. < feature {NONE}   
  822. ---
  823. > feature {RUN_FEATURE}   
  824. diff -r lib_std/std_output.e /users/prof/colnet/SmallEiffel/lib_std/std_output.elib_std/string.e /users/prof/colnet/SmallEiffel/lib_std/string.e
  825. 13c13,14
  826. <      print_on
  827. ---
  828. >      print_on, fill_tagged_out_memory, eval_read_attribute, 
  829. >      eval_write_attribute
  830. 16,17c17
  831. < creation {ANY}
  832. <    make, copy, blank
  833. ---
  834. > creation make, copy, blank, from_external
  835. 24c24
  836. < feature {ANY}
  837. ---
  838. > feature 
  839. 32c32
  840. < feature {ANY} -- Creation / Modification :
  841. ---
  842. > feature -- Creation / Modification :
  843. 40d39
  844. <      count := 0;
  845. 44,45c43
  846. <           c_inline_c("C->_storage=(char *)%
  847. <                   %malloc((size_t)a1);");
  848. ---
  849. >           storage := malloc(needed_capacity);
  850. 47,48c45
  851. <           c_inline_c("C->_storage=(char *)%
  852. <                  %realloc(C->_storage,(size_t)a1);");
  853. ---
  854. >           storage := realloc(storage,needed_capacity);
  855. 52a50
  856. >      count := 0;
  857. 71c69
  858. < feature {ANY} -- No Modification of the receiver :
  859. ---
  860. > feature -- No Modification of the receiver :
  861. 79c77
  862. <    infix "@", item(index: INTEGER): CHARACTER is
  863. ---
  864. >    item, infix "@" (index: INTEGER): CHARACTER is
  865. 83a82
  866. >      if storage = Void then end;
  867. 112c111
  868. <    infix "<" (other: STRING): BOOLEAN is
  869. ---
  870. >    infix "<" (other: like Current): BOOLEAN is
  871. 170d168
  872. <            Result := false;
  873. 175c173
  874. <           (i = 0) or else (not item(i).same_as(other @ i))
  875. ---
  876. >           (i = 0) or else (not item(i).same_as(other.item(i)))
  877. 184c182
  878. <    is_equal(other: STRING): BOOLEAN is
  879. ---
  880. >    is_equal(other: like Current): BOOLEAN is
  881. 186,187d183
  882. <       require else
  883. <      true
  884. 288c284
  885. < feature {ANY} -- Modification :
  886. ---
  887. > feature -- Modification :
  888. 299c295
  889. <    copy(other: STRING) is
  890. ---
  891. >    copy(other: like Current) is
  892. 304,323c300,301
  893. <      i := other.count;
  894. <      count := i;
  895. <      if i > 0 then
  896. <         if capacity < i then
  897. <            if capacity = 0 then
  898. <           c_inline_c("C->_storage=(char *)%
  899. <                  %malloc((size_t)_i);");
  900. <            else
  901. <           c_inline_c("C->_storage=(char *)%
  902. <                  %realloc(C->_storage,(size_t)_i);");
  903. <            end;
  904. <            capacity := i;
  905. <         end;
  906. <         from
  907. <         until
  908. <            i = 0
  909. <         loop
  910. <            put(other.item(i),i);
  911. <            i := i - 1;
  912. <         end;
  913. ---
  914. >      if capacity < other.count then
  915. >         make(other.count);
  916. 324a303,311
  917. >      from
  918. >         i := other.count;
  919. >         count := i;
  920. >      until
  921. >         i = 0
  922. >      loop
  923. >         put(other.item(i),i);
  924. >         i := i - 1;
  925. >      end;
  926. 356c343
  927. <         extend(other @ i);
  928. ---
  929. >         extend(other.item(i));
  930. 391c378
  931. <         put(other @ i,i);
  932. ---
  933. >         put(other.item(i),i);
  934. 402a390
  935. >      if storage = Void then end;
  936. 509,519c497,503
  937. <      count := count + 1;
  938. <      if capacity < count then
  939. <         if capacity = 0 then
  940. <            capacity := 16;
  941. <            c_inline_c("C->_storage=(char *)%
  942. <                %malloc((size_t)C->_capacity);");
  943. <         else
  944. <            capacity := capacity + 16;
  945. <            c_inline_c("C->_storage=(char *)realloc(%
  946. <               %C->_storage,(size_t)C->_capacity);");
  947. <         end;
  948. ---
  949. >      if capacity > count then
  950. >      elseif capacity = 0 then
  951. >         capacity := 32;
  952. >         storage := malloc(capacity);
  953. >      else
  954. >         capacity := capacity + 32;
  955. >         storage := realloc(storage,capacity);
  956. 520a505
  957. >      count := count + 1;
  958. 642c627
  959. < feature {ANY}   -- Features which don't modify the string
  960. ---
  961. > feature -- Features which don't modify the string
  962. 658c643
  963. < feature {ANY} -- Conversion :
  964. ---
  965. > feature -- Conversion :
  966. 834c819
  967. < feature {ANY} -- Printing :
  968. ---
  969. > feature -- Printing :
  970. 837,838d821
  971. <       local
  972. <      i: INTEGER;
  973. 840,849c823,825
  974. <      file.put_character('%"');
  975. <      from  
  976. <         i := 1;
  977. <      until
  978. <         i > count
  979. <      loop
  980. <         file.put_character(item(i));
  981. <         i := i +1;
  982. <      end;
  983. <      file.put_character('%"');
  984. ---
  985. >            tagged_out_memory.clear;
  986. >      fill_tagged_out_memory;
  987. >      file.put_string(tagged_out_memory);
  988. 852c828,833
  989. < feature {ANY} -- Other features :
  990. ---
  991. >    fill_tagged_out_memory is
  992. >       do
  993. >      tagged_out_memory.extend('%"'); 
  994. >      tagged_out_memory.append(Current); 
  995. >      tagged_out_memory.extend('%"'); 
  996. >       end;
  997. 853a835,836
  998. > feature -- Other features :
  999. >    
  1000. 954a938,939
  1001. > 
  1002. > feature -- Interfacing with C string :
  1003. 957,960c942,947
  1004. <      -- Gives address of a copy of the contents of the string
  1005. <      -- adding null character at end (for C use). 
  1006. <      -- NOTE: do a malloc(`count' + 1), thus it is not an access 
  1007. <      -- to `storage'.
  1008. ---
  1009. >      -- Gives C access to the internal storage of STRING.
  1010. >      -- To be compatible with C, a null character is always
  1011. >      -- appended at the end of internal storage. 
  1012. >      -- The added null character is not part of the Eiffel STRING.
  1013. >      -- 
  1014. >      -- NOTE: do not free/realloc the Result.
  1015. 962,964c949,953
  1016. <      c_inline_c("R=(char *)malloc((C->_count)+1);%N%
  1017. <             %memcpy(R,C->_storage,C->_count);%N%
  1018. <             %((char *)R)[C->_count]='\0';");
  1019. ---
  1020. >      extend('%U');
  1021. >      remove_last(1);
  1022. >      Result := storage;
  1023. >       ensure
  1024. >      Result.is_not_void
  1025. 966c955,978
  1026. <    
  1027. ---
  1028. > 
  1029. >    from_external(p: POINTER) is
  1030. >      -- Assume `p' is the addresse of a C string.
  1031. >      -- Initialize the string using `p'.
  1032. >      -- The null character is not part of the Eiffel STRING.
  1033. >       do
  1034. >      if storage.is_not_void then
  1035. >         free(storage);
  1036. >      end;
  1037. >      from
  1038. >         storage := p;
  1039. >         capacity := 1;
  1040. >         count := 1;
  1041. >      until
  1042. >         item(capacity) = '%U'
  1043. >      loop
  1044. >         capacity := capacity + 1;
  1045. >         count := capacity;
  1046. >      end;
  1047. >      count := count - 1;
  1048. >       ensure
  1049. >      p = to_external;
  1050. >       end;
  1051. > 
  1052. 969c981,1006
  1053. <    tmp_string: STRING is "ABCDEFGHIJKLMN...";
  1054. ---
  1055. >    tmp_string: STRING is 
  1056. >       once
  1057. >      !!Result.make(256);
  1058. >       end;
  1059. > 
  1060. > feature {PROC_CALL_1}
  1061. > 
  1062. >    malloc(size: INTEGER): POINTER is
  1063. >       require
  1064. >      size > 0
  1065. >       do
  1066. >      c_inline_c("R=(char*)malloc((size_t)a1);");
  1067. >       end;
  1068. > 
  1069. >    realloc(pointer: POINTER; size: INTEGER): POINTER is
  1070. >       require
  1071. >      size > 0
  1072. >       do
  1073. >      c_inline_c("R=(char*)realloc(a1,(size_t)a2);");
  1074. >       end;
  1075. > 
  1076. >    free(p: POINTER) is
  1077. >       external "C"
  1078. >       end;
  1079. > 
  1080. > feature
  1081. 970a1008,1035
  1082. >    eval_read_attribute(name: STRING; dest: POINTER) is
  1083. >       do 
  1084. >      if ("count").is_equal(name) then
  1085. >         eval_virtual_machine.put_integer(dest,count);
  1086. >      elseif ("capacity").is_equal(name) then
  1087. >         eval_virtual_machine.put_integer(dest,capacity);
  1088. >      else
  1089. >         check
  1090. >            ("storage").is_equal(name)
  1091. >         end;
  1092. >         eval_virtual_machine.put_pointer(dest,storage);
  1093. >      end;
  1094. >       end;
  1095. > 
  1096. >    eval_write_attribute(name: STRING; source: POINTER) is
  1097. >       do 
  1098. >      if ("count").is_equal(name) then
  1099. >         count := eval_virtual_machine.get_integer(source);
  1100. >      elseif ("capacity").is_equal(name) then
  1101. >         capacity := eval_virtual_machine.get_integer(source);
  1102. >      else
  1103. >         check
  1104. >            ("storage").is_equal(name)
  1105. >         end;
  1106. >         storage := eval_virtual_machine.get_pointer(source);
  1107. >      end;
  1108. >       end;
  1109. > 
  1110. 980d1044
  1111. < 
  1112.